package adke.managers;

import adke.gui.animations.*;
import adke.gui.animations.PowerupAnimation;
import adke.gui.panels.GFXPanel2;
import adke.listeners.GameListener;
import adke.listeners.PlayerListener;
import adke.listeners.PowerupListener;
import adke.models.Player;
import adke.models.powerups.AbilityPowerup;
import adke.models.powerups.Powerup;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.util.Vector;
import java.util.concurrent.CopyOnWriteArrayList;

// dit is de queue voor animaties
// deze manager houd bij welke animaties in welke volgorde getekend moeten worden

// de animaties hebben zelf eigen paameters nodig

public class AnimationManager implements PowerupListener, PlayerListener, GameListener
{
    // vanwege een concurrentmodificationexception kunnen we niet invoegen
    // terwijl we itereren. we kunnen dus geen vector gebruiken
    private static CopyOnWriteArrayList<Animation> queue;
    
    public AnimationManager()
    {
        queue = new CopyOnWriteArrayList();
        GamePowerupManager.addPowerupListener(this);
        GameManager.addListener(this);
    }
    
    // definieer hoelang de animatie maximaal door mag gaan
    public static void queueAnimation(Animation animation, int duration) // aantal frames dat hij moet runnen = duration
    {
        animation.setDuration(duration);
        queue.add(animation);
    }
    
    // run een animatie slechts een enkele keer
    public static void queueAnimationOnce(Animation animation)
    {
        queue.add(animation);
    }
    
    public static void runAnimations()
    {
        Graphics2D g = (Graphics2D)GFXPanel2.getInstance().getDrawer();
        
        Rectangle repaintRegion = null;
        for (Animation a : queue)
        {
            if (!a.isDone())
            {
                repaintRegion = a.nextFrame(g);
                g.dispose();
                //GFXPanel2.getInstance().paintRegion(repaintRegion);
            }
            else
            {
            	a.clear(g);
                removeAnimation(a);
            }
        }
        
        // teken nu de nieuwe GFX buffer
        GFXPanel2.getInstance().repaint();
    }

    public static void removeAnimation(Animation animation)
    {
        queue.remove(animation);
    }

    // LISTENERS
    
    public void powerupActivated(AbilityPowerup powerup)
    {
    }

    public void powerupDeactivated(AbilityPowerup powerup)
    {
    }

    public void powerupDropped(Powerup powerup)
    {
    	// de powerup zelf.
    	// de animatie is momenteel het squishy zijn van de powerup
        queueAnimationOnce(new PowerupAnimation(powerup));
    }

    public void powerupPickedUp(Powerup powerup)
    {
    	//Player owner = powerup.getOwner();
    	queueAnimationOnce(new TextAnimation(powerup));
    }

    public void playerDied(Player deadPlayer)
    {
    }

    public void playerKilledPlayer(Player killer, Player victim)
    {
    }

    public void gameStarted()
    {
    }

    public void gameEnded()
    {
    }

    // bij elke nieuwe ronde moeten de animaties van de vorige gewist worden
    public void roundStarted()
    {
        queue.clear();
    }

    public void roundEnded()
    {
    }
}
